// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
using System;
using System.Collections.Immutable;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.Completion;
using Microsoft.CodeAnalysis.Editor.UnitTests;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.LanguageService;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.VisualStudio.Composition;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
 
namespace Microsoft.CodeAnalysis.Test.Utilities.Completion
{
    [UseExportProvider]
    public abstract class AbstractArgumentProviderTests<TWorkspaceFixture> : TestBase
        where TWorkspaceFixture : TestWorkspaceFixture, new()
    {
        private static readonly TestComposition s_baseComposition = EditorTestCompositions.EditorFeatures.AddExcludedPartTypes(typeof(ArgumentProvider));
 
        private readonly TestFixtureHelper<TWorkspaceFixture> _fixtureHelper = new();
 
        private ExportProvider? _lazyExportProvider;
 
        protected ExportProvider ExportProvider
            => _lazyExportProvider ??= GetComposition().ExportProviderFactory.CreateExportProvider();
 
        protected virtual TestComposition GetComposition()
            => s_baseComposition.AddParts(GetArgumentProviderType());
 
        private protected ReferenceCountedDisposable<TWorkspaceFixture> GetOrCreateWorkspaceFixture()
            => _fixtureHelper.GetOrCreateFixture();
 
        internal abstract Type GetArgumentProviderType();
 
        protected abstract (SyntaxNode argumentList, ImmutableArray<SyntaxNode> arguments) GetArgumentList(SyntaxToken token);
 
        private protected async Task VerifyDefaultValueAsync(
            string markup,
            string? expectedDefaultValue,
            string? previousDefaultValue = null,
            OptionsCollection? options = null)
        {
            using var workspaceFixture = GetOrCreateWorkspaceFixture();
 
            var workspace = workspaceFixture.Target.GetWorkspace(markup, GetComposition());
            var code = workspaceFixture.Target.Code;
            var position = workspaceFixture.Target.Position;
 
            options?.SetGlobalOptions(workspace.GlobalOptions);
 
            var document = workspaceFixture.Target.UpdateDocument(code, SourceCodeKind.Regular);
 
            var provider = workspace.ExportProvider.GetExportedValues<ArgumentProvider>().Single();
            Assert.IsType(GetArgumentProviderType(), provider);
 
            var root = await document.GetRequiredSyntaxRootAsync(CancellationToken.None);
            var semanticModel = await document.GetRequiredSemanticModelAsync(CancellationToken.None);
            var parameter = GetParameterSymbolInfo(workspace, semanticModel, root, position, CancellationToken.None);
            Contract.ThrowIfNull(parameter);
 
            var context = new ArgumentContext(provider, semanticModel, position, parameter, previousDefaultValue, CancellationToken.None);
            await provider.ProvideArgumentAsync(context);
 
            Assert.Equal(expectedDefaultValue, context.DefaultValue);
        }
 
        private IParameterSymbol GetParameterSymbolInfo(Workspace workspace, SemanticModel semanticModel, SyntaxNode root, int position, CancellationToken cancellationToken)
        {
            var token = root.FindToken(position);
            var (argumentList, arguments) = GetArgumentList(token);
            var symbols = semanticModel.GetSymbolInfo(argumentList.GetRequiredParent(), cancellationToken).GetAllSymbols();
 
            // if more than one symbol is found, filter to only include symbols with a matching number of arguments
            if (symbols.Length > 1)
            {
                symbols = symbols.WhereAsArray(
                    symbol =>
                    {
                        var parameters = symbol.GetParameters();
                        if (arguments.Length < GetMinimumArgumentCount(parameters))
                            return false;
 
                        if (arguments.Length > GetMaximumArgumentCount(parameters))
                            return false;
 
                        return true;
                    });
            }
 
            var symbol = symbols.Single();
            var parameters = symbol.GetParameters();
 
            var syntaxFacts = workspace.Services.GetLanguageServices(root.Language).GetRequiredService<ISyntaxFactsService>();
            Contract.ThrowIfTrue(arguments.Any(argument => syntaxFacts.IsNamedArgument(argument)), "Named arguments are not currently supported by this test.");
            Contract.ThrowIfTrue(parameters.Any(parameter => parameter.IsParams), "'params' parameters are not currently supported by this test.");
 
            var index = arguments.Any()
                ? arguments.IndexOf(arguments.Single(argument => argument.FullSpan.Start <= position && argument.FullSpan.End >= position))
                : 0;
 
            return parameters[index];
 
            // Local functions
            static int GetMinimumArgumentCount(ImmutableArray<IParameterSymbol> parameters)
                => parameters.Count(parameter => !parameter.IsOptional && !parameter.IsParams);
 
            static int GetMaximumArgumentCount(ImmutableArray<IParameterSymbol> parameters)
                => parameters.Any(parameter => parameter.IsParams) ? int.MaxValue : parameters.Length;
        }
    }
}